//! # RustCloud 重构后工具使用示例
//!
//! 本示例展示了如何使用 rustcloud-core 中新增的工具类来替代原有的重复实现。

use std::collections::HashMap;
use std::time::Duration;

// 注意：在实际使用中，需要启用相应的 feature flags
// rustcloud-core = { path = "../rustcloud-core", features = ["auth-tools", "http-tools", "config-tools"] }

#[cfg(feature = "example-code")]
mod examples {
    use super::*;
    use rustcloud_core::auth::{PrincipalBuilder, PrincipalConverter, PermissionCheckerFactory};
    use rustcloud_core::http_client::{HttpClientConfig, HttpClientFactory};
    use rustcloud_core::config_builder::{ConnectionPoolConfig, RetryConfig, ConfigFactory};
    use rustcloud_security::prelude::*;

    /// 示例 1：使用 Principal 构建器替代重复的 Principal 创建逻辑
    pub async fn example_principal_builder() {
        println!("🔨 示例 1：Principal 构建器使用");

        // 1. 从 JWT Claims 创建 Principal（替代 JWT 认证提供者中的重复逻辑）
        let mut claims = HashMap::new();
        claims.insert("name".to_string(), serde_json::Value::String("张三".to_string()));
        claims.insert("user_type".to_string(), serde_json::Value::String("admin".to_string()));
        claims.insert("roles".to_string(), serde_json::Value::Array(vec![
            serde_json::Value::String("admin".to_string()),
            serde_json::Value::String("user".to_string()),
        ]));
        claims.insert("permissions".to_string(), serde_json::Value::Array(vec![
            serde_json::Value::String("users:read".to_string()),
            serde_json::Value::String("users:write".to_string()),
        ]));

        let jwt_principal = PrincipalConverter::from_jwt_claims("user123".to_string(), &claims).build();
        println!("✅ 从 JWT Claims 创建 Principal: {}", jwt_principal.name);

        // 2. 从 API Key 信息创建 Principal（替代 API Key 认证提供者中的重复逻辑）
        let api_principal = PrincipalConverter::from_api_key_info(
            "key456".to_string(),
            "service:payment".to_string(),
            vec!["service".to_string()],
            vec!["payment:read".to_string(), "payment:write".to_string()],
            HashMap::new(),
            None,
        ).build();
        println!("✅ 从 API Key 创建 Principal: {}", api_principal.name);

        // 3. 手动构建 Principal（提供最大灵活性）
        let custom_principal = PrincipalBuilder::new("custom123".to_string())
            .name("自定义用户".to_string())
            .principal_type(PrincipalType::User)
            .role("operator".to_string())
            .permission("data:read".to_string())
            .attribute("department".to_string(), "技术部".to_string())
            .expires_after(Duration::from_secs(3600))
            .build();
        println!("✅ 手动构建 Principal: {}", custom_principal.name);
    }

    /// 示例 2：使用统一的权限检查器替代重复的权限检查逻辑
    pub async fn example_permission_checker() {
        println!("\n🔐 示例 2：权限检查器使用");

        // 1. 创建测试用的 Principal
        let admin_principal = PrincipalBuilder::new("admin001".to_string())
            .name("管理员".to_string())
            .principal_type(PrincipalType::Admin)
            .role("admin".to_string())
            .permission("*".to_string())
            .build();

        let user_principal = PrincipalBuilder::new("user001".to_string())
            .name("普通用户".to_string())
            .principal_type(PrincipalType::User)
            .role("user".to_string())
            .permission("users:read".to_string())
            .permission("profiles:*".to_string())
            .build();

        // 2. 创建权限检查器（替代各模块中重复的 DefaultPermissionChecker）
        let checker = PermissionCheckerFactory::create_default();

        // 3. 权限检查示例
        let admin_check = checker.check(&admin_principal, "users:write").await.unwrap();
        println!("✅ 管理员权限检查 (users:write): {}", admin_check);

        let user_read_check = checker.check(&user_principal, "users:read").await.unwrap();
        println!("✅ 用户读权限检查 (users:read): {}", user_read_check);

        let user_write_check = checker.check(&user_principal, "users:write").await.unwrap();
        println!("❌ 用户写权限检查 (users:write): {}", user_write_check);

        let profile_check = checker.check(&user_principal, "profiles:update").await.unwrap();
        println!("✅ 用户通配符权限检查 (profiles:update): {}", profile_check);

        // 4. 资源权限检查
        let resource = Resource::new(
            "user-service".to_string(),
            "/api/users".to_string(),
            "GET".to_string(),
        );
        let resource_check = checker.check_resource(&user_principal, &resource).await.unwrap();
        println!("✅ 资源权限检查: {}", resource_check);
    }

    /// 示例 3：使用统一的 HTTP 客户端工具替代重复的客户端配置
    pub async fn example_http_client() {
        println!("\n🌐 示例 3：HTTP 客户端工具使用");

        // 1. 使用预定义的配置创建客户端
        println!("使用预定义配置创建 HTTP 客户端：");

        #[cfg(feature = "reqwest")]
        {
            let config_client = HttpClientFactory::create_config_client();
            match config_client {
                Ok(_) => println!("✅ 配置客户端创建成功"),
                Err(e) => println!("❌ 配置客户端创建失败: {}", e),
            }

            let transport_client = HttpClientFactory::create_transport_client();
            match transport_client {
                Ok(_) => println!("✅ 传输客户端创建成功"),
                Err(e) => println!("❌ 传输客户端创建失败: {}", e),
            }

            let gateway_client = HttpClientFactory::create_gateway_client();
            match gateway_client {
                Ok(_) => println!("✅ 网关客户端创建成功"),
                Err(e) => println!("❌ 网关客户端创建失败: {}", e),
            }
        }

        // 2. 使用自定义配置创建客户端
        let custom_config = HttpClientConfig::builder()
            .timeout(Duration::from_secs(15))
            .retry_count(5)
            .max_connections(200)
            .user_agent("CustomApp/1.0".to_string())
            .build();

        match custom_config {
            Ok(config) => {
                println!("✅ 自定义 HTTP 配置创建成功");
                println!("   - 超时时间: {:?}", config.timeout);
                println!("   - 重试次数: {}", config.retry_count);
                println!("   - 最大连接数: {}", config.max_connections);

                #[cfg(feature = "reqwest")]
                {
                    let custom_client = HttpClientFactory::create_reqwest_client(&config);
                    match custom_client {
                        Ok(_) => println!("✅ 自定义客户端创建成功"),
                        Err(e) => println!("❌ 自定义客户端创建失败: {}", e),
                    }
                }
            }
            Err(e) => println!("❌ 自定义配置创建失败: {}", e),
        }
    }

    /// 示例 4：使用统一的配置构建器替代重复的配置构建逻辑
    pub async fn example_config_builders() {
        println!("\n⚙️ 示例 4：配置构建器使用");

        // 1. 使用工厂方法创建标准配置
        println!("使用工厂方法创建标准配置：");
        
        let dev_pool = ConfigFactory::create_dev_connection_pool();
        println!("✅ 开发环境连接池配置 - 最大连接数: {}", dev_pool.max_connections);

        let prod_pool = ConfigFactory::create_prod_connection_pool();
        println!("✅ 生产环境连接池配置 - 最大连接数: {}", prod_pool.max_connections);

        let fast_retry = ConfigFactory::create_fast_retry();
        println!("✅ 快速重试配置 - 最大尝试次数: {}", fast_retry.max_attempts);

        let slow_retry = ConfigFactory::create_slow_retry();
        println!("✅ 慢速重试配置 - 最大尝试次数: {}", slow_retry.max_attempts);

        // 2. 使用构建器自定义配置
        println!("\n使用构建器创建自定义配置：");

        let custom_pool = ConnectionPoolConfig::builder()
            .max_connections(50)
            .min_connections(5)
            .connection_timeout(Duration::from_secs(10))
            .idle_timeout(Duration::from_secs(120))
            .validation_enabled(true)
            .build();

        match custom_pool {
            Ok(config) => {
                println!("✅ 自定义连接池配置创建成功");
                println!("   - 最大连接数: {}", config.max_connections);
                println!("   - 最小连接数: {}", config.min_connections);
                println!("   - 连接超时: {:?}", config.connection_timeout);
            }
            Err(e) => println!("❌ 自定义连接池配置创建失败: {}", e),
        }

        let custom_retry = RetryConfig::builder()
            .max_attempts(7)
            .base_delay(Duration::from_millis(200))
            .max_delay(Duration::from_secs(60))
            .exponential_backoff(true)
            .jitter(true)
            .build();

        match custom_retry {
            Ok(config) => {
                println!("✅ 自定义重试配置创建成功");
                println!("   - 最大尝试次数: {}", config.max_attempts);
                println!("   - 基础延迟: {:?}", config.base_delay);
                println!("   - 最大延迟: {:?}", config.max_delay);
                
                // 测试延迟计算
                let delay1 = config.calculate_delay(0);
                let delay2 = config.calculate_delay(1);
                println!("   - 第 1 次重试延迟: {:?}", delay1);
                println!("   - 第 2 次重试延迟: {:?}", delay2);
            }
            Err(e) => println!("❌ 自定义重试配置创建失败: {}", e),
        }
    }

    /// 综合示例：在实际认证流程中使用重构后的工具
    pub async fn comprehensive_example() {
        println!("\n🎯 综合示例：完整认证流程");

        // 1. 模拟从 JWT 认证创建 Principal
        let mut jwt_claims = HashMap::new();
        jwt_claims.insert("name".to_string(), serde_json::Value::String("李四".to_string()));
        jwt_claims.insert("user_type".to_string(), serde_json::Value::String("user".to_string()));
        jwt_claims.insert("roles".to_string(), serde_json::Value::Array(vec![
            serde_json::Value::String("operator".to_string()),
        ]));
        jwt_claims.insert("permissions".to_string(), serde_json::Value::Array(vec![
            serde_json::Value::String("orders:read".to_string()),
            serde_json::Value::String("orders:write".to_string()),
        ]));

        let principal = PrincipalConverter::from_jwt_claims("user789".to_string(), &jwt_claims).build();
        println!("1️⃣ 从 JWT 创建用户主体: {}", principal.name);

        // 2. 创建权限检查器
        let permission_checker = PermissionCheckerFactory::create_default();

        // 3. 定义要访问的资源
        let order_resource = Resource::new(
            "order-service".to_string(),
            "/api/orders".to_string(),
            "POST".to_string(),
        );

        // 4. 进行权限检查
        let access_allowed = permission_checker.check_resource(&principal, &order_resource).await.unwrap();
        println!("2️⃣ 资源访问权限检查结果: {}", access_allowed);

        // 5. 如果有权限，创建 HTTP 客户端进行请求
        if access_allowed {
            println!("3️⃣ 权限验证通过，创建 HTTP 客户端进行请求");
            
            let http_config = HttpClientConfig::for_gateway();
            println!("   - 使用网关 HTTP 配置");
            println!("   - 超时时间: {:?}", http_config.timeout);
            println!("   - 最大连接数: {}", http_config.max_connections);

            #[cfg(feature = "reqwest")]
            {
                let client = HttpClientFactory::create_reqwest_client(&http_config);
                match client {
                    Ok(_) => println!("✅ HTTP 客户端创建成功，可以发起请求"),
                    Err(e) => println!("❌ HTTP 客户端创建失败: {}", e),
                }
            }
        } else {
            println!("❌ 权限验证失败，拒绝访问");
        }

        println!("4️⃣ 认证流程完成");
    }
}

/// 主函数：运行所有示例
#[tokio::main]
async fn main() {
    println!("🚀 RustCloud 重构后工具使用示例");
    println!("=====================================");

    #[cfg(feature = "example-code")]
    {
        examples::example_principal_builder().await;
        examples::example_permission_checker().await;
        examples::example_http_client().await;
        examples::example_config_builders().await;
        examples::comprehensive_example().await;
    }

    #[cfg(not(feature = "example-code"))]
    {
        println!("💡 要运行示例代码，请启用 'example-code' feature：");
        println!("   cargo run --features example-code");
        println!();
        println!("📚 重构总结：");
        println!("   ✅ Principal 构建器 - 统一了 3 处重复的 Principal 创建逻辑");
        println!("   ✅ 权限检查器 - 统一了 3 处重复的权限检查实现");
        println!("   ✅ HTTP 客户端工具 - 统一了 4+ 处重复的客户端配置");
        println!("   ✅ 配置构建器 - 统一了多处重复的构建器模式");
        println!();
        println!("🎯 重构收益：");
        println!("   📈 代码复用率显著提升");
        println!("   🛠️ 维护成本大幅降低");  
        println!("   🏗️ 架构一致性增强");
        println!("   ⚡ 开发效率提升");
    }

    println!();
    println!("📖 详细文档请参考: docs/代码重复分析与重构总结.md");
}